
//二刷dfs
//class Solution {
//    static final int[][] DIRS = new int[][]{{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
//
//    public int islandPerimeter(int[][] grid) {
//        int[] islandPos = findIsland(grid);
//        boolean[][] visited = new boolean[grid.length][grid[0].length];
//        return dfs(grid, visited, islandPos[0], islandPos[1]);
//    }
//
//    int[] findIsland(int[][] grid) {
//        for (int i = 0; i < grid.length; i++) {
//            for (int j = 0; j < grid[0].length; j++) {
//                if (grid[i][j] == 1) {
//                    return new int[]{i, j};
//                }
//            }
//        }
//        throw new RuntimeException("hahaha");
//    }
//
//    boolean inBounds(int[][] grid, int i, int j) {
//        return i >= 0 && i < grid.length && j >= 0 && j < grid[0].length;
//    }
//
//    int dfs(int[][] grid, boolean[][] visited, int i, int j) {
//        if (visited[i][j]) {
//            System.out.println("ERROR1");
//        }
//        visited[i][j] = true;
//        int len = 0;
//        for (int[] dir : DIRS) {
//            int nextI = i + dir[0];
//            int nextJ = j + dir[1];
//            if (!inBounds(grid, nextI, nextJ)) {
//                len += 1;
//            }
//            else if (!visited[nextI][nextJ]) {
//                if (grid[nextI][nextJ] == 1) {
//                    len += dfs(grid, visited, nextI, nextJ);
//                } else {
//                    len += 1;
//                }
//            }
//        }
//        return len;
//    }
//}

////dfs
//class Solution {
//    final private static int[][] DIR = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
//
//    public int islandPerimeter(int[][] grid) {
//        int H = grid.length, W = grid[0].length;
//        boolean[][] visited = new boolean[H][W];
//        for (int r = 0; r < H; r++) {
//            for (int c = 0; c < W; c++) {
//                if (grid[r][c] == 1 && !visited[r][c]) {
//                    return dfs(grid, r, c, visited);
//                }
//            }
//        }
//        return 0;
//    }
//
//    private boolean inBounds(int[][] grid, int r, int c) {
//        int H = grid.length, W = grid[0].length;
//        return r >= 0 && r < H && c >= 0 && c < W;
//    }
//
//    private int dfs(int[][] grid, int r, int c, boolean[][] visited) {
//        visited[r][c] = true;
//
//        int partialPer = 0;
//        for (int[] dir : DIR) {
//            int nextR = r + dir[0];
//            int nextC = c + dir[1];
//            if (!inBounds(grid, nextR, nextC) || grid[nextR][nextC] == 0) {
//                partialPer += 1;
//                continue;
//            }
//
//            // grid[nextR][nextC] == 1
//            if (visited[nextR][nextC]) {
//                continue;
//            }
//            partialPer += dfs(grid, nextR, nextC, visited);
//        }
//
//        return partialPer;
//    }
//}

import java.util.List;

//迭代
class Solution {

    static final int[][] NEIGHBORS = new int[][]{{1, 0}, {0, 1}, {-1, 0}, {0, -1}};

    public int islandPerimeter(int[][] grid) {
        int ans = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 0) {
                    continue;
                }

                for (int[] neighbor : NEIGHBORS) {
                    int nI = i + neighbor[0];
                    int nJ = j + neighbor[1];
                    if (!inBounds(grid, nI, nJ) || grid[nI][nJ] == 0) {
                        ans++;
                    }
                }
            }
        }
        return ans;
    }

    boolean inBounds(int[][] grid, int i, int j) {
        return i >= 0 && i < grid.length && j >= 0 && j < grid[0].length;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello world!");
    }
}